home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / QuickDraw3D 1.6 SDK / Mac Interfaces / PInterfaces / QD3DRenderer.p < prev    next >
Encoding:
Text File  |  1999-05-18  |  42.0 KB  |  1,262 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        QD3DRenderer.p
  3.  
  4.      Contains:    Q3Renderer types and routines                                          
  5.  
  6.      Version:    Technology:    Quickdraw 3D 1.6
  7.                  Release:    QuickTime 4.0
  8.  
  9.      Copyright:    © 1995-1999 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT QD3DRenderer;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __QD3DRENDERER__}
  27. {$SETC __QD3DRENDERER__ := 1}
  28.  
  29. {$I+}
  30. {$SETC QD3DRendererIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __QD3D__}
  34. {$I QD3D.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED __QD3DSET__}
  37. {$I QD3DSet.p}
  38. {$ENDC}
  39. {$IFC UNDEFINED __QD3DVIEW__}
  40. {$I QD3DView.p}
  41. {$ENDC}
  42. {$IFC UNDEFINED __RAVE__}
  43. {$I RAVE.p}
  44. {$ENDC}
  45.  
  46. {$IFC TARGET_OS_MAC }
  47. {$IFC UNDEFINED __EVENTS__}
  48. {$I Events.p}
  49. {$ENDC}
  50. {$ENDC}  {TARGET_OS_MAC}
  51.  
  52.  
  53. {$PUSH}
  54. {$ALIGN POWER}
  55. {$LibExport+}
  56.  
  57. {*****************************************************************************
  58.  **                                                                             **
  59.  **                            User Interface Things                             **
  60.  **                                                                             **
  61.  ****************************************************************************}
  62. {$IFC TARGET_OS_MAC }
  63. {
  64.  *  A callback to an application's event handling code. This is needed to    
  65.  *  support movable modal dialogs. The dialog's event filter calls this      
  66.  *  callback with events it does not handle.                                 
  67.  *  If an application handles the event it should return kQ3True.            
  68.  *  If the application does not handle the event it must return kQ3False and 
  69.  *  the dialog's event filter will pass the event to the system unhandled.   
  70.  }
  71.  
  72. TYPE
  73. {$IFC TYPED_FUNCTION_POINTERS}
  74.     TQ3MacOSDialogEventHandler = FUNCTION({CONST}VAR event: EventRecord): TQ3Boolean; C;
  75. {$ELSEC}
  76.     TQ3MacOSDialogEventHandler = ProcPtr;
  77. {$ENDC}
  78.  
  79.     TQ3DialogAnchorPtr = ^TQ3DialogAnchor;
  80.     TQ3DialogAnchor = RECORD
  81.         clientEventHandler:        TQ3MacOSDialogEventHandler;
  82.     END;
  83.  
  84. {$ENDC}  {TARGET_OS_MAC}
  85.  
  86. {$IFC TARGET_OS_WIN32 }
  87.  
  88. TYPE
  89.     TQ3DialogAnchor = RECORD
  90.         ownerWindow:            HWND;
  91.     END;
  92.  
  93. {$ENDC}  {TARGET_OS_WIN32}
  94.  
  95. {$IFC TARGET_OS_UNIX }
  96.  
  97. TYPE
  98.     TQ3DialogAnchorPtr = ^TQ3DialogAnchor;
  99.     TQ3DialogAnchor = RECORD
  100.         notUsed:                Ptr;                                    {  place holder  }
  101.     END;
  102.  
  103. {$ENDC}  {TARGET_OS_UNIX}
  104.  
  105. {*****************************************************************************
  106.  **                                                                             **
  107.  **                            Renderer Functions                                 **
  108.  **                                                                             **
  109.  ****************************************************************************}
  110. FUNCTION Q3Renderer_NewFromType(rendererObjectType: TQ3ObjectType): TQ3RendererObject; C;
  111. FUNCTION Q3Renderer_GetType(renderer: TQ3RendererObject): TQ3ObjectType; C;
  112.  
  113. { Q3Renderer_Flush has been replaced by Q3View_Flush }
  114. { Q3Renderer_Sync has been replaced by Q3View_Sync }
  115.  
  116. {
  117.  *    Q3Renderer_IsInteractive
  118.  *        Determine if this renderer is intended to be used interactively.
  119.  }
  120. FUNCTION Q3Renderer_IsInteractive(renderer: TQ3RendererObject): TQ3Boolean; C;
  121.  
  122. {
  123.  *    Q3Renderer_HasModalConfigure
  124.  *        Determine if this renderer has a modal settings dialog.
  125.  *
  126.  *    Q3Renderer_ModalConfigure
  127.  *        Have the renderer pop up a modal dialog box to configure its settings.
  128.  *    dialogAnchor - is platform specific data passed by the client to support
  129.  *      movable modal dialogs. 
  130.  *    MacOS: this is a callback to the calling application's event handler.
  131.  *      The renderer calls this function with events not handled by the 
  132.  *      settings dialog. This is necessary in order to support movable modal 
  133.  *      dialogs. An application's event handler must return kQ3True if it 
  134.  *      handles the event passed to the callback or kQ3False if not. 
  135.  *      An application which doesn't want to support a movable modal configure
  136.  *      dialog should pass NULL for the clientEventHandler of TQ3DialogAnchor.
  137.  *    Win32: this is the HWND of the owning window (typically an application's
  138.  *      main window).
  139.  *  canceled - returns a boolean inditacating that the user canceled the 
  140.  *    dialog.
  141.  *      
  142.  }
  143. FUNCTION Q3Renderer_HasModalConfigure(renderer: TQ3RendererObject): TQ3Boolean; C;
  144. FUNCTION Q3Renderer_ModalConfigure(renderer: TQ3RendererObject; dialogAnchor: TQ3DialogAnchor; VAR canceled: TQ3Boolean): TQ3Status; C;
  145. {
  146.  *    Q3RendererClass_GetNickNameString
  147.  *        Allows an application to get a renderers name string, the 
  148.  *        renderer is responsible for storing this in a localizable format
  149.  *        for example as a resource.  This string can then be used to provide
  150.  *        a selection mechanism for an application (for example in a menu).
  151.  *
  152.  *        If this call returns nil in the supplied string, then the App may 
  153.  *         choose to use the class name for the renderer.  You should always 
  154.  *        try to get the name string before using the class name, since the
  155.  *        class name is not localizable.
  156.  }
  157. FUNCTION Q3RendererClass_GetNickNameString(rendererClassType: TQ3ObjectType; VAR rendererClassString: TQ3ObjectClassNameString): TQ3Status; C;
  158.  
  159. {
  160.  *    Q3Renderer_GetConfigurationData
  161.  *        Allows an application to collect private renderer configuration data
  162.  *      which it will then save. For example in a preference file or in a 
  163.  *        style template. An application should tag this data with the 
  164.  *        Renderer's object  name.
  165.  *    
  166.  *        if dataBuffer is NULL actualDataSize returns the required size in 
  167.  *        bytes of a data buffer large enough to store private data. 
  168.  *
  169.  *      bufferSize is the actual size of the memory block pointed to by 
  170.  *        dataBuffer
  171.  *
  172.  *        actualDataSize - on return the actual number of bytes written to the 
  173.  *        buffer or if dataBuffer is NULL the required size of dataBuffer
  174.  * 
  175.  }
  176. FUNCTION Q3Renderer_GetConfigurationData(renderer: TQ3RendererObject; VAR dataBuffer: UInt8; bufferSize: UInt32; VAR actualDataSize: UInt32): TQ3Status; C;
  177. FUNCTION Q3Renderer_SetConfigurationData(renderer: TQ3RendererObject; VAR dataBuffer: UInt8; bufferSize: UInt32): TQ3Status; C;
  178.  
  179.  
  180. {*****************************************************************************
  181.  **                                                                             **
  182.  **                        Interactive Renderer Specific Functions                 **
  183.  **                                                                             **
  184.  ****************************************************************************}
  185. { CSG IDs attribute }
  186. { Object IDs, to be applied as attributes on geometries }
  187.  
  188. CONST
  189.     kQ3AttributeTypeConstructiveSolidGeometryID = 'csgi';
  190.  
  191.     kQ3SolidGeometryObjNone        = -1;
  192.     kQ3SolidGeometryObjA        = 0;
  193.     kQ3SolidGeometryObjB        = 1;
  194.     kQ3SolidGeometryObjC        = 2;
  195.     kQ3SolidGeometryObjD        = 3;
  196.     kQ3SolidGeometryObjE        = 4;
  197.  
  198. { Possible CSG equations }
  199.  
  200. TYPE
  201.     TQ3CSGEquation                 = SInt32;
  202. CONST
  203.     kQ3CSGEquationAandB            = $88888888;
  204.     kQ3CSGEquationAandnotB        = $22222222;
  205.     kQ3CSGEquationAanBonCad        = $2F222F22;
  206.     kQ3CSGEquationnotAandB        = $44444444;
  207.     kQ3CSGEquationnAaBorCanB    = $74747474;
  208.  
  209. FUNCTION Q3InteractiveRenderer_SetCSGEquation(renderer: TQ3RendererObject; equation: TQ3CSGEquation): TQ3Status; C;
  210. FUNCTION Q3InteractiveRenderer_GetCSGEquation(renderer: TQ3RendererObject; VAR equation: TQ3CSGEquation): TQ3Status; C;
  211. FUNCTION Q3InteractiveRenderer_SetPreferences(renderer: TQ3RendererObject; vendorID: LONGINT; engineID: LONGINT): TQ3Status; C;
  212. FUNCTION Q3InteractiveRenderer_GetPreferences(renderer: TQ3RendererObject; VAR vendorID: LONGINT; VAR engineID: LONGINT): TQ3Status; C;
  213. FUNCTION Q3InteractiveRenderer_SetDoubleBufferBypass(renderer: TQ3RendererObject; bypass: TQ3Boolean): TQ3Status; C;
  214. FUNCTION Q3InteractiveRenderer_GetDoubleBufferBypass(renderer: TQ3RendererObject; VAR bypass: TQ3Boolean): TQ3Status; C;
  215. FUNCTION Q3InteractiveRenderer_SetRAVEContextHints(renderer: TQ3RendererObject; RAVEContextHints: UInt32): TQ3Status; C;
  216. FUNCTION Q3InteractiveRenderer_GetRAVEContextHints(renderer: TQ3RendererObject; VAR RAVEContextHints: UInt32): TQ3Status; C;
  217. FUNCTION Q3InteractiveRenderer_SetRAVETextureFilter(renderer: TQ3RendererObject; RAVEtextureFilterValue: UInt32): TQ3Status; C;
  218. FUNCTION Q3InteractiveRenderer_GetRAVETextureFilter(renderer: TQ3RendererObject; VAR RAVEtextureFilterValue: UInt32): TQ3Status; C;
  219. FUNCTION Q3InteractiveRenderer_CountRAVEDrawContexts(renderer: TQ3RendererObject; VAR numRAVEContexts: UInt32): TQ3Status; C;
  220.  
  221. TYPE
  222. {$IFC TYPED_FUNCTION_POINTERS}
  223.     TQ3RaveDestroyCallback = PROCEDURE(renderer: TQ3RendererObject); C;
  224. {$ELSEC}
  225.     TQ3RaveDestroyCallback = ProcPtr;
  226. {$ENDC}
  227.  
  228. FUNCTION Q3InteractiveRenderer_GetRAVEDrawContexts(renderer: TQ3RendererObject; VAR raveDrawContextList: TQADrawContextPtr; VAR raveDrawingEnginesList: TQAEnginePtr; VAR numRAVEContexts: UInt32; raveDestroyCallback: TQ3RaveDestroyCallback): TQ3Status; C;
  229.  
  230.  
  231.  
  232. {*****************************************************************************
  233.  **                                                                             **
  234.  **                            Renderer View Tools                                 **
  235.  **                                                                             **
  236.  **                    You may only call these methods from a plug-in             **
  237.  **                                                                             **
  238.  ****************************************************************************}
  239. {
  240.  *    Call by a renderer to call the user "idle" method, with progress 
  241.  *    information.
  242.  *    
  243.  *    Pass in (view, 0, n) on first call
  244.  *    Pass in (view, 1..n-1, n) during rendering
  245.  *    Pass in (view, n, n) upon completion
  246.  *    
  247.  *    Note: The user must have supplied an idleProgress method with 
  248.  *    Q3XView_SetIdleProgressMethod. Otherwise, the generic idle method is
  249.  *    called with no progress data. e.g. the Q3View_SetIdleMethod method
  250.  *    is called instead. (current and final are ignored, essentially.)
  251.  *
  252.  *    Returns kQ3Failure if rendering is cancelled.
  253.  }
  254. FUNCTION Q3XView_IdleProgress(view: TQ3ViewObject; current: UInt32; completed: UInt32): TQ3Status; C;
  255. {
  256.  *    Called by an asynchronous renderer when it completes a frame.
  257.  }
  258. FUNCTION Q3XView_EndFrame(view: TQ3ViewObject): TQ3Status; C;
  259.  
  260. {*****************************************************************************
  261.  **                                                                             **
  262.  **                            Renderer AttributeSet Tools                         **
  263.  **                                                                             **
  264.  **                    You may only call these methods from a plug-in             **
  265.  **                                                                             **
  266.  ****************************************************************************}
  267. {
  268.  *    Faster access to geometry attribute sets.
  269.  *    
  270.  *    Returns pointer to INTERNAL data structure for elements and attributes
  271.  *    in an attributeSet, or NULL if no attribute exists.
  272.  *    
  273.  *    For attributes of type kQ3AttributeType..., the internal data structure
  274.  *    is identical to the data structure used in Q3AttributeSet_Add.
  275.  }
  276. FUNCTION Q3XAttributeSet_GetPointer(attributeSet: TQ3AttributeSet; attributeType: TQ3AttributeType): Ptr; C;
  277.  
  278.  
  279. CONST
  280.     kQ3XAttributeMaskNone        = 0;
  281.     kQ3XAttributeMaskSurfaceUV    = $01;
  282.     kQ3XAttributeMaskShadingUV    = $02;
  283.     kQ3XAttributeMaskNormal        = $04;
  284.     kQ3XAttributeMaskAmbientCoefficient = $08;
  285.     kQ3XAttributeMaskDiffuseColor = $10;
  286.     kQ3XAttributeMaskSpecularColor = $20;
  287.     kQ3XAttributeMaskSpecularControl = $40;
  288.     kQ3XAttributeMaskTransparencyColor = $80;
  289.     kQ3XAttributeMaskSurfaceTangent = $0100;
  290.     kQ3XAttributeMaskHighlightState = $0200;
  291.     kQ3XAttributeMaskSurfaceShader = $0400;
  292.     kQ3XAttributeMaskCustomAttribute = $80000000;
  293.     kQ3XAttributeMaskAll        = $800007FF;
  294.     kQ3XAttributeMaskInherited    = $03FF;
  295.     kQ3XAttributeMaskInterpolated = $01FF;
  296.  
  297.  
  298. TYPE
  299.     TQ3XAttributeMask                    = UInt32;
  300. FUNCTION Q3XAttributeSet_GetMask(attributeSet: TQ3AttributeSet): TQ3XAttributeMask; C;
  301.  
  302. {*****************************************************************************
  303.  **                                                                             **
  304.  **                            Renderer Draw Context Tools                         **
  305.  **                                                                             **
  306.  ****************************************************************************}
  307.  
  308. TYPE
  309.     TQ3XDrawRegion = ^LONGINT;
  310. FUNCTION Q3XDrawContext_GetDrawRegion(drawContext: TQ3DrawContextObject; VAR drawRegion: TQ3XDrawRegion): TQ3Status; C;
  311.  
  312. TYPE
  313.     TQ3XDrawContextValidationMasks  = SInt32;
  314. CONST
  315.     kQ3XDrawContextValidationClearFlags = $00000000;
  316.     kQ3XDrawContextValidationDoubleBuffer = $01;
  317.     kQ3XDrawContextValidationShader = $02;
  318.     kQ3XDrawContextValidationClearFunction = $04;
  319.     kQ3XDrawContextValidationActiveBuffer = $08;
  320.     kQ3XDrawContextValidationInternalOffScreen = $10;
  321.     kQ3XDrawContextValidationPane = $20;
  322.     kQ3XDrawContextValidationMask = $40;
  323.     kQ3XDrawContextValidationDevice = $80;
  324.     kQ3XDrawContextValidationWindow = $0100;
  325.     kQ3XDrawContextValidationWindowSize = $0200;
  326.     kQ3XDrawContextValidationWindowClip = $0400;
  327.     kQ3XDrawContextValidationWindowPosition = $0800;
  328.     kQ3XDrawContextValidationPlatformAttributes = $1000;
  329.     kQ3XDrawContextValidationForegroundShader = $2000;
  330.     kQ3XDrawContextValidationBackgroundShader = $4000;
  331.     kQ3XDrawContextValidationColorPalette = $8000;
  332.     kQ3XDrawContextValidationAll = $FFFFFFFF;
  333.  
  334.  
  335. TYPE
  336.     TQ3XDrawContextValidation            = UInt32;
  337. FUNCTION Q3XDrawContext_ClearValidationFlags(drawContext: TQ3DrawContextObject): TQ3Status; C;
  338. FUNCTION Q3XDrawContext_GetValidationFlags(drawContext: TQ3DrawContextObject; VAR validationFlags: TQ3XDrawContextValidation): TQ3Status; C;
  339.  
  340. {*****************************************************************************
  341.  **                                                                             **
  342.  **                            Renderer Draw Region Tools                         **
  343.  **                                                                             **
  344.  ****************************************************************************}
  345.  
  346. TYPE
  347.     TQ3XDevicePixelType         = SInt32;
  348. CONST
  349.                                                                 {  These do not indicate byte ordering    }
  350.     kQ3XDevicePixelTypeInvalid    = 0;                            {  Unknown, un-initialized type      }
  351.     kQ3XDevicePixelTypeRGB32    = 1;                            {  Alpha:8 (ignored), R:8, G:8, B:8  }
  352.     kQ3XDevicePixelTypeARGB32    = 2;                            {  Alpha:8, R:8, G:8, B:8               }
  353.     kQ3XDevicePixelTypeRGB24    = 3;                            {  24 bits/pixel, R:8, G:8, B:8      }
  354.     kQ3XDevicePixelTypeRGB16    = 4;                            {  Alpha:1 (ignored), R:5, G:5, B:5  }
  355.     kQ3XDevicePixelTypeARGB16    = 5;                            {  Alpha:1, R:5, G:5, B:5               }
  356.     kQ3XDevicePixelTypeRGB16_565 = 6;                            {  16 bits/pixel, R:5, G:6, B:5      }
  357.     kQ3XDevicePixelTypeIndexed8    = 7;                            {  8-bit color table index              }
  358.     kQ3XDevicePixelTypeIndexed4    = 8;                            {  4-bit color table index              }
  359.     kQ3XDevicePixelTypeIndexed2    = 9;                            {  2-bit color table index              }
  360.     kQ3XDevicePixelTypeIndexed1    = 10;                            {  1-bit color table index              }
  361.  
  362.  
  363. TYPE
  364.     TQ3XClipMaskState             = SInt32;
  365. CONST
  366.     kQ3XClipMaskFullyExposed    = 0;
  367.     kQ3XClipMaskPartiallyExposed = 1;
  368.     kQ3XClipMaskNotExposed        = 2;
  369.  
  370.  
  371. TYPE
  372.     TQ3XColorDescriptorPtr = ^TQ3XColorDescriptor;
  373.     TQ3XColorDescriptor = RECORD
  374.         redShift:                UInt32;
  375.         redMask:                UInt32;
  376.         greenShift:                UInt32;
  377.         greenMask:                UInt32;
  378.         blueShift:                UInt32;
  379.         blueMask:                UInt32;
  380.         alphaShift:                UInt32;
  381.         alphaMask:                UInt32;
  382.     END;
  383.  
  384.     TQ3XDrawRegionDescriptorPtr = ^TQ3XDrawRegionDescriptor;
  385.     TQ3XDrawRegionDescriptor = RECORD
  386.         width:                    UInt32;
  387.         height:                    UInt32;
  388.         rowBytes:                UInt32;
  389.         pixelSize:                UInt32;
  390.         pixelType:                TQ3XDevicePixelType;
  391.         colorDescriptor:        TQ3XColorDescriptor;
  392.         bitOrder:                TQ3Endian;
  393.         byteOrder:                TQ3Endian;
  394.         clipMask:                TQ3BitmapPtr;
  395.     END;
  396.  
  397.     TQ3XDrawRegionServicesMasks  = SInt32;
  398. CONST
  399.     kQ3XDrawRegionServicesNoneFlag = 0;
  400.     kQ3XDrawRegionServicesClearFlag = $01;
  401.     kQ3XDrawRegionServicesDontLockDDSurfaceFlag = $02;
  402.  
  403.  
  404. TYPE
  405.     TQ3XDrawRegionServices                = UInt32;
  406. {$IFC TYPED_FUNCTION_POINTERS}
  407.     TQ3XDrawRegionRendererPrivateDeleteMethod = PROCEDURE(rendererPrivate: UNIV Ptr); C;
  408. {$ELSEC}
  409.     TQ3XDrawRegionRendererPrivateDeleteMethod = ProcPtr;
  410. {$ENDC}
  411.  
  412. FUNCTION Q3XDrawRegion_GetDeviceScaleX(drawRegion: TQ3XDrawRegion; VAR deviceScaleX: Single): TQ3Status; C;
  413. FUNCTION Q3XDrawRegion_GetDeviceScaleY(drawRegion: TQ3XDrawRegion; VAR deviceScaleY: Single): TQ3Status; C;
  414.  
  415. FUNCTION Q3XDrawRegion_GetDeviceOffsetX(drawRegion: TQ3XDrawRegion; VAR deviceOffsetX: Single): TQ3Status; C;
  416. FUNCTION Q3XDrawRegion_GetDeviceOffsetY(drawRegion: TQ3XDrawRegion; VAR deviceOffsetX: Single): TQ3Status; C;
  417.  
  418. FUNCTION Q3XDrawRegion_GetWindowScaleX(drawRegion: TQ3XDrawRegion; VAR windowScaleX: Single): TQ3Status; C;
  419. FUNCTION Q3XDrawRegion_GetWindowScaleY(drawRegion: TQ3XDrawRegion; VAR windowScaleY: Single): TQ3Status; C;
  420.  
  421. FUNCTION Q3XDrawRegion_GetWindowOffsetX(drawRegion: TQ3XDrawRegion; VAR windowOffsetX: Single): TQ3Status; C;
  422. FUNCTION Q3XDrawRegion_GetWindowOffsetY(drawRegion: TQ3XDrawRegion; VAR windowOffsetY: Single): TQ3Status; C;
  423. FUNCTION Q3XDrawRegion_IsActive(drawRegion: TQ3XDrawRegion; VAR isActive: TQ3Boolean): TQ3Status; C;
  424.  
  425. FUNCTION Q3XDrawRegion_GetNextRegion(drawRegion: TQ3XDrawRegion; VAR nextDrawRegion: TQ3XDrawRegion): TQ3Status; C;
  426. { 
  427.  *  One of the next two functions must be called before using a draw region 
  428.  }
  429. {
  430.  *    Use this Start function if double buffering/image access services from the
  431.  *    Draw Context are not needed, you may still request clear for example
  432.  }
  433. FUNCTION Q3XDrawRegion_Start(drawRegion: TQ3XDrawRegion; services: TQ3XDrawRegionServices; VAR descriptor: TQ3XDrawRegionDescriptorPtr): TQ3Status; C;
  434. {
  435.  *    Use this Start function if double buffering or image access services from 
  436.  *  the Draw Context are needed.
  437.  }
  438. FUNCTION Q3XDrawRegion_StartAccessToImageBuffer(drawRegion: TQ3XDrawRegion; services: TQ3XDrawRegionServices; VAR descriptor: TQ3XDrawRegionDescriptorPtr; VAR image: UNIV Ptr): TQ3Status; C;
  439. {
  440.  *    This function is used to indicate that access to a DrawRegion is ended.
  441.  }
  442. FUNCTION Q3XDrawRegion_End(drawRegion: TQ3XDrawRegion): TQ3Status; C;
  443. FUNCTION Q3XDrawRegion_GetDeviceTransform(drawRegion: TQ3XDrawRegion; VAR deviceTransform: TQ3Matrix4x4Ptr): TQ3Status; C;
  444. FUNCTION Q3XDrawRegion_GetClipFlags(drawRegion: TQ3XDrawRegion; VAR clipMaskState: TQ3XClipMaskState): TQ3Status; C;
  445. FUNCTION Q3XDrawRegion_GetClipMask(drawRegion: TQ3XDrawRegion; VAR clipMask: TQ3BitmapPtr): TQ3Status; C;
  446. {$IFC TARGET_OS_MAC }
  447. FUNCTION Q3XDrawRegion_GetClipRegion(drawRegion: TQ3XDrawRegion; VAR rgnHandle: RgnHandle): TQ3Status; C;
  448. FUNCTION Q3XDrawRegion_GetGDHandle(drawRegion: TQ3XDrawRegion; VAR gdHandle: GDHandle): TQ3Status; C;
  449. {$ENDC}  {TARGET_OS_MAC}
  450.  
  451. FUNCTION Q3XDrawRegion_GetRendererPrivate(drawRegion: TQ3XDrawRegion; VAR rendererPrivate: UNIV Ptr): TQ3Status; C;
  452. FUNCTION Q3XDrawRegion_SetRendererPrivate(drawRegion: TQ3XDrawRegion; rendererPrivate: UNIV Ptr; deleteMethod: TQ3XDrawRegionRendererPrivateDeleteMethod): TQ3Status; C;
  453. FUNCTION Q3XDrawRegion_SetUseDefaultRendererFlag(drawRegion: TQ3XDrawRegion; flag: TQ3Boolean): TQ3Status; C;
  454. FUNCTION Q3XDrawRegion_GetUseDefaultRendererFlag(drawRegion: TQ3XDrawRegion; VAR useDefaultRenderingFlag: TQ3Boolean): TQ3Status; C;
  455.  
  456.  
  457. {*****************************************************************************
  458.  **                                                                             **
  459.  **                            Renderer Class Methods                             **
  460.  **                                                                             **
  461.  ****************************************************************************}
  462. {
  463.  *    Methods from Object
  464.  *        kQ3XMethodTypeObjectClassRegister
  465.  *        kQ3XMethodTypeObjectClassUnregister
  466.  *        kQ3XMethodTypeObjectNew
  467.  *        kQ3XMethodTypeObjectDelete
  468.  *        kQ3XMethodTypeObjectRead
  469.  *        kQ3XMethodTypeObjectTraverse
  470.  *        kQ3XMethodTypeObjectWrite
  471.  *        
  472.  *    Methods from Shared
  473.  *        kQ3MethodTypeSharedEdited
  474.  *
  475.  *    Renderer Methods
  476.  *    
  477.  *    The renderer methods should be implemented according to the type
  478.  *    of renderer being written.
  479.  *
  480.  *    For the purposes of documentation, there are two basic types of
  481.  *    renderers: 
  482.  *
  483.  *        Interactive
  484.  *            Interactive Renderer
  485.  *            WireFrame Renderer
  486.  *        
  487.  *        Deferred
  488.  *            a ray-tracer
  489.  *            painter's algorithm renderer (cached in a BSP triangle tree)
  490.  *            an artistic renderer (simulates a pencil drawing, etc.)
  491.  *
  492.  *    The main difference is how each renderer handles incoming state and 
  493.  *    geometry.
  494.  *
  495.  *    An interactive renderer immediately transforms, culls, and shades
  496.  *    incoming geometry and performs rasterization. For example, in a 
  497.  *    single-buffered WireFrame renderer, you will see a new triangle
  498.  *    immediately after Q3Triangle_Draw (if it's visible, of course).
  499.  *
  500.  *    A deferred renderer caches the view state and each geometry, 
  501.  *    converting into any internal queue of drawing commands. Rasterization
  502.  *    is not actually performed until all data has been submitted.
  503.  *    
  504.  *    For example, a ray-tracer may not rasterize anything until the
  505.  *    end of the rendering loop, or until an EndFrame call is made.
  506.  }
  507.  
  508. {*****************************************************************************
  509.  **                                                                             **
  510.  **                        Renderer User Interface Methods                         **
  511.  **                                                                             **
  512.  ****************************************************************************}
  513. {
  514.  *    kQ3XMethodTypeRendererIsInteractive
  515.  *    
  516.  *    There is no actual method with this - the metahandler simply returns
  517.  *  "(TQ3XFunctionPointer)kQ3True" for this "method" if the renderer is 
  518.  *  intended to be used in interactive settings, and   
  519.  *    "(TQ3XFunctionPointer)kQ3False" otherwise. 
  520.  *  
  521.  *  If neither value is specified in the metahandler, the renderer 
  522.  *  is *assumed to be non-interactive*!!!
  523.  *    
  524.  *    OPTIONAL
  525.  }
  526.  
  527. CONST
  528.     kQ3XMethodTypeRendererIsInteractive = 'isin';
  529.  
  530.  
  531. {
  532.  *    TQ3XRendererModalConfigureMethod
  533.  *    
  534.  *    This method should pop up a modal dialog to edit the renderer settings 
  535.  *    found in the renderer private. 
  536.  *    
  537.  *    dialogAnchor - is platform specific data passed by the client to support
  538.  *      movable modal dialogs. 
  539.  *    MacOS: this is a callback to the calling application's event handler.
  540.  *      The renderer calls this function with events not handled by the 
  541.  *      settings dialog. This is necessary in order to support movable modal 
  542.  *      dialogs. An application's event handler must return kQ3True if it 
  543.  *      handles the event passed to the callback or kQ3False if not. 
  544.  *      An application which doesn't want to support a movable modal configure
  545.  *      dialog should pass NULL for the clientEventHandler of TQ3DialogAnchor.
  546.  *      A renderer should implement a non-movable style dialog in that case.
  547.  *    Win32: this is the HWND of the owning window (typically an application's
  548.  *      main window).  (Win32 application modal dialogs are always movable.)
  549.  *  canceled - returns a boolean inditacating that the user canceled the 
  550.  *    dialog.
  551.  *    
  552.  *    OPTIONAL
  553.  }
  554.     kQ3XMethodTypeRendererModalConfigure = 'rdmc';
  555.  
  556.  
  557. TYPE
  558. {$IFC TYPED_FUNCTION_POINTERS}
  559.     TQ3XRendererModalConfigureMethod = FUNCTION(renderer: TQ3RendererObject; dialogAnchor: TQ3DialogAnchor; VAR canceled: TQ3Boolean; rendererPrivate: UNIV Ptr): TQ3Status; C;
  560. {$ELSEC}
  561.     TQ3XRendererModalConfigureMethod = ProcPtr;
  562. {$ENDC}
  563.  
  564. {
  565.  *    kQ3XMethodTypeRendererGetNickNameString
  566.  *    
  567.  *        Allows an application to collect the name of the renderer for
  568.  *        display in a user interface item such as a menu.
  569.  *    
  570.  *        If dataBuffer is NULL actualDataSize returns the required size in 
  571.  *        bytes of a data buffer large enough to store the renderer name. 
  572.  *
  573.  *      bufferSize is the actual size of the memory block pointed to by 
  574.  *        dataBuffer
  575.  *
  576.  *        actualDataSize - on return the actual number of bytes written to the
  577.  *        buffer or if dataBuffer is NULL the required size of dataBuffer
  578.  *
  579.  *    OPTIONAL
  580.  }
  581.  
  582. CONST
  583.     kQ3XMethodTypeRendererGetNickNameString = 'rdns';
  584.  
  585.  
  586. TYPE
  587. {$IFC TYPED_FUNCTION_POINTERS}
  588.     TQ3XRendererGetNickNameStringMethod = FUNCTION(VAR dataBuffer: UInt8; bufferSize: UInt32; VAR actualDataSize: UInt32): TQ3Status; C;
  589. {$ELSEC}
  590.     TQ3XRendererGetNickNameStringMethod = ProcPtr;
  591. {$ENDC}
  592.  
  593. {
  594.  *    kQ3XMethodTypeRendererGetConfigurationData
  595.  *    
  596.  *        Allows an application to collect private configuration data from the
  597.  *      renderer which it will then save. For example in a preference file, 
  598.  *      a registry key (on Windows) or in a style template. An application 
  599.  *      should tag this data with the renderer's object name.
  600.  *    
  601.  *        If dataBuffer is NULL actualDataSize returns the required size in 
  602.  *        bytes of a data buffer large enough to store private data. 
  603.  *
  604.  *      bufferSize is the actual size of the memory block pointed to by 
  605.  *        dataBuffer
  606.  *
  607.  *        actualDataSize - on return the actual number of bytes written to the
  608.  *        buffer or if dataBuffer is NULL the required size of dataBuffer
  609.  *
  610.  *    OPTIONAL
  611.  }
  612.  
  613. CONST
  614.     kQ3XMethodTypeRendererGetConfigurationData = 'rdgp';
  615.  
  616.  
  617. TYPE
  618. {$IFC TYPED_FUNCTION_POINTERS}
  619.     TQ3XRendererGetConfigurationDataMethod = FUNCTION(renderer: TQ3RendererObject; VAR dataBuffer: UInt8; bufferSize: UInt32; VAR actualDataSize: UInt32; rendererPrivate: UNIV Ptr): TQ3Status; C;
  620. {$ELSEC}
  621.     TQ3XRendererGetConfigurationDataMethod = ProcPtr;
  622. {$ENDC}
  623.  
  624. {
  625.  *    TQ3XRendererSetConfigurationDataMethod
  626.  *    
  627.  *        Allows an application to pass private configuration data which has
  628.  *         previously  been obtained from a renderer via 
  629.  *        Q3Renderer_GetConfigurationData. For example in a preference file or 
  630.  *        in a style template. An application should tag this data with the 
  631.  *        renderer's object name.
  632.  *    
  633.  *      bufferSize is the actual size of the memory block pointed to by 
  634.  *        dataBuffer
  635.  *
  636.  *    OPTIONAL
  637.  }
  638.  
  639. CONST
  640.     kQ3XMethodTypeRendererSetConfigurationData = 'rdsp';
  641.  
  642.  
  643. TYPE
  644. {$IFC TYPED_FUNCTION_POINTERS}
  645.     TQ3XRendererSetConfigurationDataMethod = FUNCTION(renderer: TQ3RendererObject; VAR dataBuffer: UInt8; bufferSize: UInt32; rendererPrivate: UNIV Ptr): TQ3Status; C;
  646. {$ELSEC}
  647.     TQ3XRendererSetConfigurationDataMethod = ProcPtr;
  648. {$ENDC}
  649.  
  650. {*****************************************************************************
  651.  **                                                                             **
  652.  **                        Renderer Drawing State Methods                         **
  653.  **                                                                             **
  654.  ****************************************************************************}
  655. {
  656.  *    TQ3RendererStartFrame
  657.  *    
  658.  *    The StartFrame method is called first at Q3View_StartRendering
  659.  *    and should:
  660.  *        - initialize any renderer state to defaults
  661.  *        - extract any and all useful data from the drawContext
  662.  *
  663.  *    If your renderer passed in kQ3RendererFlagClearBuffer at 
  664.  *    registration, then it should also:
  665.  *        - clear the drawContext 
  666.  *    
  667.  *        When clearing, your renderer may opt to:
  668.  *        - NOT clear anything (if you touch every pixel, for example)
  669.  *        - to clear with your own routine, or
  670.  *        - to use the draw context default clear method by calling 
  671.  *        Q3DrawContext_Clear. Q3DrawContext_Clear takes advantage of
  672.  *        any available hardware in the system for clearing.
  673.  *    
  674.  *    This call also signals the start of all default submit commands from
  675.  *    the view. The renderer will receive updates for the default view
  676.  *    state via its Update methods before StartPass is called.
  677.  *    
  678.  *    REQUIRED
  679.  }
  680.  
  681. CONST
  682.     kQ3XMethodTypeRendererStartFrame = 'rdcl';
  683.  
  684.  
  685. TYPE
  686. {$IFC TYPED_FUNCTION_POINTERS}
  687.     TQ3XRendererStartFrameMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; drawContext: TQ3DrawContextObject): TQ3Status; C;
  688. {$ELSEC}
  689.     TQ3XRendererStartFrameMethod = ProcPtr;
  690. {$ENDC}
  691.  
  692. {
  693.  *    kQ3XMethodTypeRendererStartPass
  694.  *    TQ3XRendererStartPassMethod
  695.  *    
  696.  *    The StartPass method is called during Q3View_StartRendering but after
  697.  *    the StartFrame command. It should:
  698.  *        - collect camera and light information
  699.  *    
  700.  *    If your renderer supports deferred camera transformation, camera is the
  701.  *    main camera which will be submitted in the hierarchy somewhere. It
  702.  *    is never NULL.
  703.  *
  704.  *    If your renderer does not support deferred camera transformation, camera
  705.  *    is the transformed camera.
  706.  *
  707.  *    If your renderer supports deferred light transformation, lights will be
  708.  *    NULL, and will be submitted to your light draw methods instead.
  709.  *
  710.  *    This call signals the end of the default update state, and the start of 
  711.  *  submit commands from the user to the view.
  712.  *
  713.  *    REQUIRED
  714.  }
  715.  
  716. CONST
  717.     kQ3XMethodTypeRendererStartPass = 'rdst';
  718.  
  719.  
  720. TYPE
  721. {$IFC TYPED_FUNCTION_POINTERS}
  722.     TQ3XRendererStartPassMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; camera: TQ3CameraObject; lightGroup: TQ3GroupObject): TQ3Status; C;
  723. {$ELSEC}
  724.     TQ3XRendererStartPassMethod = ProcPtr;
  725. {$ENDC}
  726.  
  727. {
  728.  *    kQ3XMethodTypeRendererFlushFrame
  729.  *    TQ3XRendererFlushFrameMethod
  730.  *    
  731.  *    This call is only implemented by asynchronous renderers.
  732.  *    
  733.  *    The FlushFrame method is called between the StartPass and EndPass
  734.  *    methods and is called when the user wishes to flush any asynchronous
  735.  *    drawing tasks (which draw to the drawcontext), but does not want 
  736.  *    to block.
  737.  *    
  738.  *    The result of this call is that an image should "eventually" appear
  739.  *    asynchronously.
  740.  *    
  741.  *    For asynchronous rendering, this call is non-blocking.
  742.  *    
  743.  *    An interactive renderer should ensure that all received
  744.  *    geometries are drawn in the image.
  745.  *    
  746.  *    An interactive renderer that talks to hardware should force
  747.  *    the hardware to generate an image.
  748.  *    
  749.  *    A deferred renderer should exhibit a similar behaviour,
  750.  *    though it is not required.  A deferred renderer should spawn
  751.  *    a process that generates a partial image from the currently
  752.  *    accumulated drawing state. 
  753.  *    
  754.  *    However, for renderers such as ray-tracers which generally are
  755.  *    quite compute-intensive, FlushFrame is not required and is a no-op.
  756.  *
  757.  *    OPTIONAL
  758.  }
  759.  
  760. CONST
  761.     kQ3XMethodTypeRendererFlushFrame = 'rdfl';
  762.  
  763.  
  764. TYPE
  765. {$IFC TYPED_FUNCTION_POINTERS}
  766.     TQ3XRendererFlushFrameMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; drawContext: TQ3DrawContextObject): TQ3Status; C;
  767. {$ELSEC}
  768.     TQ3XRendererFlushFrameMethod = ProcPtr;
  769. {$ENDC}
  770.  
  771. {
  772.  *    kQ3XMethodTypeRendererEndPass
  773.  *    TQ3XRendererEndPassMethod
  774.  *    
  775.  *    The EndPass method is called at Q3View_EndRendering and signals
  776.  *    the end of submit commands to the view.
  777.  *
  778.  *    If an error occurs, the renderer should call Q3XError_Post and
  779.  *    return kQ3ViewStatusError.
  780.  *    
  781.  *    If a renderer requires another pass on the renderering data,
  782.  *    it should return kQ3ViewStatusRetraverse.
  783.  *    
  784.  *    If rendering was cancelled, this function will not be called
  785.  *    and the view will handle returning kQ3ViewStatusCancelled;
  786.  *    
  787.  *    Otherwise, your renderer should begin completing the process of 
  788.  *    generating the image in the drawcontext. If you have buffered
  789.  *    any drawing data, flush it. RendererEnd should have a similar
  790.  *    effect as RendererFlushFrame.
  791.  *    
  792.  *    If the renderer is synchronous:
  793.  *        - complete rendering of the entire frame
  794.  *        if the renderer supports kQ3RendererClassSupportDoubleBuffer
  795.  *            - Update the front buffer
  796.  *        else
  797.  *            - DrawContext will update the front buffer after returning
  798.  *
  799.  *    If the renderer is asynchronous
  800.  *        - spawn rendering thread for entire frame
  801.  *        if the renderer supports kQ3RendererClassSupportDoubleBuffer,
  802.  *            - you must eventually update the front buffer asynchronously
  803.  *        else
  804.  *            - you must eventually update the back buffer asynchronously
  805.  *            
  806.  *    REQUIRED
  807.  }
  808.  
  809. CONST
  810.     kQ3XMethodTypeRendererEndPass = 'rded';
  811.  
  812.  
  813. TYPE
  814. {$IFC TYPED_FUNCTION_POINTERS}
  815.     TQ3XRendererEndPassMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr): TQ3ViewStatus; C;
  816. {$ELSEC}
  817.     TQ3XRendererEndPassMethod = ProcPtr;
  818. {$ENDC}
  819.  
  820. {
  821.  *    kQ3XMethodTypeRendererEndFrame
  822.  *    TQ3XRendererEndFrame
  823.  *    
  824.  *    This call is only implemented by asynchronous renderers.
  825.  *
  826.  *    The EndFrame method is called from Q3View_Sync, which is
  827.  *    called after Q3View_EndRendering and signals that the user
  828.  *    wishes to see the completed image and is willing to block.
  829.  *    
  830.  *    If your renderer supports kQ3RendererFlagDoubleBuffer
  831.  *        - update the front buffer completely 
  832.  *    else
  833.  *        - update the back buffer completely
  834.  *
  835.  *    This call is equivalent in functionality to RendererFlushFrame
  836.  *    but blocks until the image is completed.
  837.  *    
  838.  *    If no method is supplied, the default is a no-op.
  839.  *    
  840.  *    NOTE: Registering a method of this type indicates that your renderer will
  841.  *    be rendering after Q3View_EndRendering has been called.
  842.  *    
  843.  *    OPTIONAL
  844.  }
  845.  
  846. CONST
  847.     kQ3XMethodTypeRendererEndFrame = 'rdsy';
  848.  
  849.  
  850. TYPE
  851. {$IFC TYPED_FUNCTION_POINTERS}
  852.     TQ3XRendererEndFrameMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; drawContext: TQ3DrawContextObject): TQ3Status; C;
  853. {$ELSEC}
  854.     TQ3XRendererEndFrameMethod = ProcPtr;
  855. {$ENDC}
  856.  
  857. {
  858.  *    The RendererCancel method is called after Q3View_StartRendering
  859.  *    and signals the termination of all rendering operations.
  860.  *
  861.  *    A renderer should clean up any cached data, and cancel all 
  862.  *    rendering operations.
  863.  *    
  864.  *    If called before Q3View_EndRendering, the RendererEnd method
  865.  *    is NOT called.
  866.  *    
  867.  *    If called after Q3View_EndRendering, the renderer should kill
  868.  *    any threads and terminate any further rendering.
  869.  *    
  870.  *    REQUIRED
  871.  }
  872.  
  873. CONST
  874.     kQ3XMethodTypeRendererCancel = 'rdab';
  875.  
  876.  
  877. TYPE
  878. {$IFC TYPED_FUNCTION_POINTERS}
  879.     TQ3XRendererCancelMethod = PROCEDURE(view: TQ3ViewObject; rendererPrivate: UNIV Ptr); C;
  880. {$ELSEC}
  881.     TQ3XRendererCancelMethod = ProcPtr;
  882. {$ENDC}
  883.  
  884. {*****************************************************************************
  885.  **                                                                             **
  886.  **                        Renderer DrawContext Methods                         **
  887.  **                                                                             **
  888.  ****************************************************************************}
  889. {
  890.  *    kQ3XMethodTypeRendererPush
  891.  *    TQ3XRendererPushMethod
  892.  *    
  893.  *    kQ3XMethodTypeRendererPop
  894.  *    TQ3XRendererPopMethod
  895.  *    
  896.  *    These methods are called whenever the graphics state in the view
  897.  *    is pushed or popped. The user may isolate state by calling:
  898.  *    
  899.  *    Q3Attribute_Submit(kQ3AttributeTypeDiffuseColor, &red, view);
  900.  *    Q3Attribute_Submit(kQ3AttributeTypeTransparencyColor, &blue, view);
  901.  *    Q3Attribute_Submit(kQ3AttributeTypeSpecularColor, &white, view);
  902.  *    Q3Box_Submit(&unitBox, view);
  903.  *    Q3TranslateTransform_Submit(&unitVector, view);
  904.  *    Q3Push_Submit(view);
  905.  *        Q3Attribute_Submit(kQ3AttributeTypeDiffuseColor, &blue, view);
  906.  *        Q3Attribute_Submit(kQ3AttributeTypeTransparencyColor, &green, view);
  907.  *        Q3Box_Submit(&unitBox, view);
  908.  *    Q3Pop_Submit(view);    
  909.  *    Q3TranslateTransform_Submit(&unitVector, view);
  910.  *    Q3Box_Submit(&unitBox, view);
  911.  *    
  912.  *    or by submitting a display group which pushes and pops.
  913.  *    
  914.  *    If you support RendererPush and RendererPop in your renderer:
  915.  *        - you must maintain your drawing state as a stack, as well.
  916.  *        - you will not be updated with the popped state after
  917.  *            RendererPop is called.
  918.  *
  919.  *    If you do not support Push and Pop in your renderer:
  920.  *        - you may maintain a single copy of the drawing state.
  921.  *        - you will be updated with changed fields after the view stack is
  922.  *            popped.
  923.  *
  924.  *    A renderer that supports Push and Pop gets called in the following
  925.  *    sequence (from example above):
  926.  *    
  927.  *    RendererUpdateAttributeDiffuseColor(&red,...)
  928.  *    RendererUpdateAttributeTransparencyColor(&blue,...)
  929.  *    RendererUpdateAttributeSpecularColor(&white,...)
  930.  *    RendererUpdateMatrixLocalToWorld(...)
  931.  *    RendererSubmitGeometryBox(...)
  932.  *    RendererPush(...)
  933.  *        RendererUpdateAttributeDiffuseColor(&blue,...)
  934.  *        RendererUpdateAttributeTransparencyColor(&green,...)
  935.  *        RendererSubmitGeometryBox(...)
  936.  *    RendererPop(...)
  937.  *    RendererUpdateMatrixLocalToWorld(...)
  938.  *    RendererSubmitGeometryBox(...)
  939.  *
  940.  *    A renderer that does not supports Push and Pop gets called in the
  941.  *    following sequence:
  942.  *    
  943.  *    RendererUpdateAttributeDiffuseColor(&red,...)
  944.  *    RendererUpdateAttributeTransparencyColor(&blue,...)
  945.  *    RendererUpdateAttributeSpecularColor(&white,...)
  946.  *    RendererUpdateMatrixLocalToWorld(...)
  947.  *    RendererSubmitGeometryBox(...)
  948.  *        RendererUpdateAttributeDiffuseColor(&blue,...)
  949.  *        RendererUpdateAttributeTransparencyColor(&green,...)
  950.  *        RendererSubmitGeometryBox(...)
  951.  *    RendererUpdateAttributeDiffuseColor(&red,...)
  952.  *    RendererUpdateAttributeTransparencyColor(&blue,...)
  953.  *    RendererUpdateMatrixLocalToWorld(...)
  954.  *    RendererSubmitGeometryBox(...)
  955.  *    
  956.  }
  957.  
  958. CONST
  959.     kQ3XMethodTypeRendererPush    = 'rdps';
  960.  
  961.  
  962. TYPE
  963. {$IFC TYPED_FUNCTION_POINTERS}
  964.     TQ3XRendererPushMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr): TQ3Status; C;
  965. {$ELSEC}
  966.     TQ3XRendererPushMethod = ProcPtr;
  967. {$ENDC}
  968.  
  969.  
  970. CONST
  971.     kQ3XMethodTypeRendererPop    = 'rdpo';
  972.  
  973.  
  974. TYPE
  975. {$IFC TYPED_FUNCTION_POINTERS}
  976.     TQ3XRendererPopMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr): TQ3Status; C;
  977. {$ELSEC}
  978.     TQ3XRendererPopMethod = ProcPtr;
  979. {$ENDC}
  980.  
  981. {*****************************************************************************
  982.  **                                                                             **
  983.  **                            Renderer Cull Methods                             **
  984.  **                                                                             **
  985.  ****************************************************************************}
  986. {
  987.  *    kQ3XMethodTypeRendererIsBoundingBoxVisible
  988.  *    TQ3XRendererIsBoundingBoxVisibleMethod
  989.  *    
  990.  *    This method is called to cull complex groups and geometries 
  991.  *    given their bounding box in local space.
  992.  *    
  993.  *    It should transform the local-space bounding box coordinates to
  994.  *    frustum space and return a TQ3Boolean return value indicating
  995.  *    whether the box appears within the viewing frustum.
  996.  *    
  997.  *    If no method is supplied, the default behavior is to return
  998.  *    kQ3True.
  999.  *    
  1000.  }
  1001.  
  1002. CONST
  1003.     kQ3XMethodTypeRendererIsBoundingBoxVisible = 'rdbx';
  1004.  
  1005.  
  1006. TYPE
  1007. {$IFC TYPED_FUNCTION_POINTERS}
  1008.     TQ3XRendererIsBoundingBoxVisibleMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; {CONST}VAR bBox: TQ3BoundingBox): TQ3Boolean; C;
  1009. {$ELSEC}
  1010.     TQ3XRendererIsBoundingBoxVisibleMethod = ProcPtr;
  1011. {$ENDC}
  1012.  
  1013.  
  1014. {*****************************************************************************
  1015.  **                                                                             **
  1016.  **                        Renderer Object Support Methods                         **
  1017.  **                                                                             **
  1018.  ****************************************************************************}
  1019. {
  1020.  *    Drawing methods (Geometry, Camera, Lights)
  1021.  *
  1022.  }
  1023. {
  1024.  *    Geometry MetaHandler
  1025.  *    
  1026.  *    This metaHandler is required to support 
  1027.  *    
  1028.  *    kQ3GeometryTypeTriangle
  1029.  *    kQ3GeometryTypeLine
  1030.  *    kQ3GeometryTypePoint
  1031.  *    kQ3GeometryTypeMarker
  1032.  *    kQ3GeometryTypePixmapMarker
  1033.  *    
  1034.  *    REQUIRED
  1035.  }
  1036.  
  1037. CONST
  1038.     kQ3XMethodTypeRendererSubmitGeometryMetaHandler = 'rdgm';
  1039.  
  1040.  
  1041. TYPE
  1042. {$IFC TYPED_FUNCTION_POINTERS}
  1043.     TQ3XRendererSubmitGeometryMetaHandlerMethod = FUNCTION(geometryType: TQ3ObjectType): TQ3XFunctionPointer; C;
  1044. {$ELSEC}
  1045.     TQ3XRendererSubmitGeometryMetaHandlerMethod = ProcPtr;
  1046. {$ENDC}
  1047.  
  1048. {
  1049.  *    The TQ3XRendererSubmitGeometryMetaHandlerMethod switches on geometryType
  1050.  *    of kQ3GeometryTypeFoo and returns methods of type:
  1051.  }
  1052. {$IFC TYPED_FUNCTION_POINTERS}
  1053.     TQ3XRendererSubmitGeometryMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; geometry: TQ3GeometryObject; publicData: UNIV Ptr): TQ3Status; C;
  1054. {$ELSEC}
  1055.     TQ3XRendererSubmitGeometryMethod = ProcPtr;
  1056. {$ENDC}
  1057.  
  1058. {
  1059.  *    Camera MetaHandler
  1060.  *    
  1061.  *    This metaHandler, if supplied, indicates that your renderer
  1062.  *    handles deferred transformation of the main camera within a scene.
  1063.  *    
  1064.  *    If not supplied, or an unsupported camera is used, the view will do
  1065.  *    the transformation for the renderer and pass in a camera in the 
  1066.  *    StartPass method.
  1067.  *    
  1068.  *    OPTIONAL
  1069.  }
  1070.  
  1071. CONST
  1072.     kQ3XMethodTypeRendererSubmitCameraMetaHandler = 'rdcm';
  1073.  
  1074.  
  1075. TYPE
  1076. {$IFC TYPED_FUNCTION_POINTERS}
  1077.     TQ3XRendererSubmitCameraMetaHandlerMethod = FUNCTION(cameraType: TQ3ObjectType): TQ3XFunctionPointer; C;
  1078. {$ELSEC}
  1079.     TQ3XRendererSubmitCameraMetaHandlerMethod = ProcPtr;
  1080. {$ENDC}
  1081.  
  1082. {
  1083.  *    The TQ3XRendererSubmitCameraMetaHandlerMethod switches on cameraType
  1084.  *    of kQ3CameraTypeFoo and returns methods of type:
  1085.  }
  1086. {$IFC TYPED_FUNCTION_POINTERS}
  1087.     TQ3XRendererSubmitCameraMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; camera: TQ3CameraObject; publicData: UNIV Ptr): TQ3Status; C;
  1088. {$ELSEC}
  1089.     TQ3XRendererSubmitCameraMethod = ProcPtr;
  1090. {$ENDC}
  1091.  
  1092. {
  1093.  *    Light MetaHandler
  1094.  *    
  1095.  *    This metaHandler, if supplied, indicates that your renderer
  1096.  *    handles deferred transformation of lights within a scene.
  1097.  *    
  1098.  *    If an unsupported light is encountered, it is ignored.
  1099.  *
  1100.  *    OPTIONAL
  1101.  }
  1102.  
  1103. CONST
  1104.     kQ3XMethodTypeRendererSubmitLightMetaHandler = 'rdlg';
  1105.  
  1106.  
  1107. TYPE
  1108. {$IFC TYPED_FUNCTION_POINTERS}
  1109.     TQ3XRendererSubmitLightMetaHandlerMethod = FUNCTION(lightType: TQ3ObjectType): TQ3XFunctionPointer; C;
  1110. {$ELSEC}
  1111.     TQ3XRendererSubmitLightMetaHandlerMethod = ProcPtr;
  1112. {$ENDC}
  1113.  
  1114. {
  1115.  *    The TQ3XRendererSubmitLightMetaHandlerMethod switches on lightType
  1116.  *    of kQ3LightTypeFoo and returns methods of type:
  1117.  }
  1118. {$IFC TYPED_FUNCTION_POINTERS}
  1119.     TQ3XRendererSubmitLightMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; light: TQ3LightObject; publicData: UNIV Ptr): TQ3Status; C;
  1120. {$ELSEC}
  1121.     TQ3XRendererSubmitLightMethod = ProcPtr;
  1122. {$ENDC}
  1123.  
  1124. {
  1125.  *
  1126.  *    Update methods
  1127.  *
  1128.  *    They are called whenever the state has changed. If the renderer supports
  1129.  *    the RendererPush and RendererPop methods, it must maintain its own state
  1130.  *    stack. Updates are not called for changed data when the view stack is
  1131.  *    popped.
  1132.  *
  1133.  *    See the comments for the RendererPush and RendererPop methods above
  1134.  *    for an example of how data is updated.
  1135.  *
  1136.  }
  1137. {
  1138.  *    Style
  1139.  }
  1140.  
  1141. CONST
  1142.     kQ3XMethodTypeRendererUpdateStyleMetaHandler = 'rdyu';
  1143.  
  1144.  
  1145. TYPE
  1146. {$IFC TYPED_FUNCTION_POINTERS}
  1147.     TQ3XRendererUpdateStyleMetaHandlerMethod = FUNCTION(styleType: TQ3ObjectType): TQ3XFunctionPointer; C;
  1148. {$ELSEC}
  1149.     TQ3XRendererUpdateStyleMetaHandlerMethod = ProcPtr;
  1150. {$ENDC}
  1151.  
  1152. {
  1153.  *    The TQ3XRendererUpdateStyleMetaHandlerMethod switches on styleType
  1154.  *    of kQ3StyleTypeFoo and returns methods of type:
  1155.  }
  1156. {$IFC TYPED_FUNCTION_POINTERS}
  1157.     TQ3XRendererUpdateStyleMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; publicData: UNIV Ptr): TQ3Status; C;
  1158. {$ELSEC}
  1159.     TQ3XRendererUpdateStyleMethod = ProcPtr;
  1160. {$ENDC}
  1161.  
  1162. {
  1163.  *    Attributes
  1164.  }
  1165.  
  1166. CONST
  1167.     kQ3XMethodTypeRendererUpdateAttributeMetaHandler = 'rdau';
  1168.  
  1169.  
  1170. TYPE
  1171. {$IFC TYPED_FUNCTION_POINTERS}
  1172.     TQ3XRendererUpdateAttributeMetaHandlerMethod = FUNCTION(attributeType: TQ3AttributeType): TQ3XFunctionPointer; C;
  1173. {$ELSEC}
  1174.     TQ3XRendererUpdateAttributeMetaHandlerMethod = ProcPtr;
  1175. {$ENDC}
  1176.  
  1177. {
  1178.  *    The TQ3XRendererUpdateStyleMetaHandlerMethod switches on attributeType
  1179.  *    of kQ3AttributeTypeFoo and returns methods of type:
  1180.  }
  1181. {$IFC TYPED_FUNCTION_POINTERS}
  1182.     TQ3XRendererUpdateAttributeMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; publicData: UNIV Ptr): TQ3Status; C;
  1183. {$ELSEC}
  1184.     TQ3XRendererUpdateAttributeMethod = ProcPtr;
  1185. {$ENDC}
  1186.  
  1187. {
  1188.  *    Shaders
  1189.  }
  1190.  
  1191. CONST
  1192.     kQ3XMethodTypeRendererUpdateShaderMetaHandler = 'rdsu';
  1193.  
  1194.  
  1195. TYPE
  1196. {$IFC TYPED_FUNCTION_POINTERS}
  1197.     TQ3XRendererUpdateShaderMetaHandlerMethod = FUNCTION(shaderType: TQ3ObjectType): TQ3XFunctionPointer; C;
  1198. {$ELSEC}
  1199.     TQ3XRendererUpdateShaderMetaHandlerMethod = ProcPtr;
  1200. {$ENDC}
  1201.  
  1202. {
  1203.  *    The TQ3XRendererUpdateShaderMetaHandlerMethod switches on shaderType
  1204.  *    of kQ3ShaderTypeFoo and returns methods of type:
  1205.  }
  1206. {$IFC TYPED_FUNCTION_POINTERS}
  1207.     TQ3XRendererUpdateShaderMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; VAR shaderObject: TQ3Object): TQ3Status; C;
  1208. {$ELSEC}
  1209.     TQ3XRendererUpdateShaderMethod = ProcPtr;
  1210. {$ENDC}
  1211.  
  1212. {
  1213.  *    Matrices
  1214.  }
  1215.  
  1216. CONST
  1217.     kQ3XMethodTypeRendererUpdateMatrixMetaHandler = 'rdxu';
  1218.  
  1219.  
  1220. TYPE
  1221.     TQ3XRendererUpdateMatrixMetaHandlerMethod = TQ3XMetaHandler;
  1222. {
  1223.  *    The TQ3XRendererUpdateShaderMetaHandlerMethod switches on methods
  1224.  *    of the form kQ3MethodTypeRendererUpdateMatrixFoo:
  1225.  }
  1226.  
  1227. CONST
  1228.     kQ3XMethodTypeRendererUpdateMatrixLocalToWorld = 'ulwx';
  1229.  
  1230.     kQ3XMethodTypeRendererUpdateMatrixLocalToWorldInverse = 'ulwi';
  1231.  
  1232.     kQ3XMethodTypeRendererUpdateMatrixLocalToWorldInverseTranspose = 'ulwt';
  1233.  
  1234.     kQ3XMethodTypeRendererUpdateMatrixLocalToCamera = 'ulcx';
  1235.  
  1236.     kQ3XMethodTypeRendererUpdateMatrixLocalToFrustum = 'ulfx';
  1237.  
  1238.     kQ3XMethodTypeRendererUpdateMatrixWorldToFrustum = 'uwfx';
  1239.  
  1240. {
  1241.  *    and returns methods of type:
  1242.  }
  1243.  
  1244. TYPE
  1245. {$IFC TYPED_FUNCTION_POINTERS}
  1246.     TQ3XRendererUpdateMatrixMethod = FUNCTION(view: TQ3ViewObject; rendererPrivate: UNIV Ptr; {CONST}VAR matrix: TQ3Matrix4x4): TQ3Status; C;
  1247. {$ELSEC}
  1248.     TQ3XRendererUpdateMatrixMethod = ProcPtr;
  1249. {$ENDC}
  1250.  
  1251.  
  1252. {$ALIGN RESET}
  1253. {$POP}
  1254.  
  1255. {$SETC UsingIncludes := QD3DRendererIncludes}
  1256.  
  1257. {$ENDC} {__QD3DRENDERER__}
  1258.  
  1259. {$IFC NOT UsingIncludes}
  1260.  END.
  1261. {$ENDC}
  1262.